package com.msf.tutorial.java8.chapter7;

import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

/**
 * (1) 找出2011年发生的所有交易，并按交易额排序（从低到高）。
 * (2) 交易员都在哪些不同的城市工作过？
 * (3) 查找所有来自于剑桥的交易员，并按姓名排序。
 * (4) 返回所有交易员的姓名字符串，按字母顺序排序。
 * (5) 有没有交易员是在米兰工作的？
 * (6) 打印生活在剑桥的交易员的所有交易额。
 * (7) 所有交易中，最高的交易额是多少？
 * (8) 找到交易额最小的交易。
 */
public class C06Exam {

    class Trader {

        private String name;

        private String city;

        public Trader(String name, String city) {
            this.name = name;
            this.city = city;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getCity() {
            return city;
        }

        public void setCity(String city) {
            this.city = city;
        }
    }

    class Transaction {

        private Trader trader;

        private int year;

        private int value;

        public Transaction() {}

        public Transaction(Trader trader, int year, int value) {
            this.trader = trader;
            this.year = year;
            this.value = value;
        }

        public Trader getTrader() {
            return trader;
        }

        public void setTrader(Trader trader) {
            this.trader = trader;
        }

        public int getYear() {
            return year;
        }

        public void setYear(int year) {
            this.year = year;
        }

        public int getValue() {
            return value;
        }

        public void setValue(int value) {
            this.value = value;
        }
    }

    /**
     * 找出2011年发生的所有交易，并按交易额排序（从低到高）。
     */
    public List<Transaction> exercises_1(List<Transaction> list) {
        return list.stream()
                    .filter(t -> t.getYear() == 2011)
                    .sorted(Comparator.comparing(Transaction::getValue))
                    .collect(Collectors.toList());
    }

    /**
     * 交易员都在哪些不同的城市工作过？
     */
    public List<String> exercises_2(List<Trader> list) {
        return list.stream()
                    .map(t -> t.getCity())
                    .distinct()
                    .collect(Collectors.toList());
    }

    /**
     * 查找所有来自于剑桥的交易员，并按姓名排序。
     */
    public List<Trader> exercises_3(List<Trader> list) {
        return list.stream()
                .filter(t -> "剑桥".equals(t.getCity()))
                .sorted(Comparator.comparing(Trader::getName))
                .collect(Collectors.toList());
    }

    /**
     * 返回所有交易员的姓名字符串，按字母顺序排序。
     */
    public String exercises_4(List<Trader> list) {
        return list.stream()
                .map(t -> t.getName())
                .sorted()
                .collect(Collectors.joining());
    }

    /**
     * 有没有交易员是在米兰工作的？
     */
    public boolean exercises_5(List<Trader> list) {
        return list.stream().anyMatch(t -> "米兰".equals(t.getCity()));
    }

    /**
     * 打印生活在剑桥的交易员的所有交易额。
     */
    public void exercises_6(List<Transaction> list) {
        list.stream()
            .filter(t -> "剑桥".equals(t.getTrader().getCity()))
            .map(Transaction::getValue)
            .forEach(System.out::println);
    }

    /**
     * 所有交易中，最高的交易额是多少？
     */
    public int exercises_7(List<Transaction> list) {
        return list.stream().map(t -> t.getValue()).reduce(Integer::max).orElse(0);
    }

    /**
     * 找到交易额最小的交易。
     */
    public int exercises_8(List<Transaction> list) {
        return list.stream().min(Comparator.comparing(Transaction::getValue)).orElseGet(Transaction::new).getValue();
    }

}
